
import pandas as pd 
# для модели проверки адекватности
# from numpy.random import choice
# для графиков
import matplotlib.pyplot as plt
# метрика время исполнения
import time

# для разделения данных на выборки
from sklearn.model_selection import train_test_split 
# метрика для моделей- accuracy
# from sklearn.metrics import accuracy_score
# метрика для моделей- F1-мера
from sklearn.metrics import f1_score
# метрика для моделей AUC-ROC
from sklearn.metrics import roc_auc_score
# Классификатор Дерево решений
from sklearn.tree import DecisionTreeClassifier
from sklearn.tree import plot_tree
# Классификатор Случайный Лес 
from sklearn.ensemble import RandomForestClassifier
# Классификатор Логистическая регрессия
from sklearn.linear_model import LogisticRegression
# Классификатор для проверки адекватности
# from sklearn.dummy import DummyClassifier
# для перевода категорийных данных от строк к числам
from sklearn.preprocessing import OneHotEncoder
# для маштабирования признаков
from sklearn.preprocessing import StandardScaler
# для перемешивания выборок
from sklearn.utils import shuffle
# для изображения PR-кривой
from sklearn.metrics import precision_recall_curve
# для изображения ROC-кривой
from sklearn.metrics import roc_curve
# метрики точности и полноты
from sklearn.metrics import precision_score, recall_score

# для скрытия ошибок
import warnings

import numpy as np


# для скрытия ошибок
warnings.filterwarnings("ignore")
# pd.options.mode.chained_assignment = None

# для увеличения окна вывода 
pd.options.display.max_rows = 300


# версия для ревьюера
data = pd.read_csv('/datasets/Churn.csv')
# моя локальная версия
# data = pd.read_csv('Churn.csv')

data.head()


display(data.columns)
data.columns = ['row_number', 'customer_id', 'surname', 'credit_score', 'geography',
       'gender', 'age', 'tenure', 'balance', 'num_of_products', 'has_cr_card',
       'is_active_member', 'estimated_salary', 'exited']
data.columns

Index(['RowNumber', 'CustomerId', 'Surname', 'CreditScore', 'Geography',
       'Gender', 'Age', 'Tenure', 'Balance', 'NumOfProducts', 'HasCrCard',
       'IsActiveMember', 'EstimatedSalary', 'Exited'],
      dtype='object')

Index(['row_number', 'customer_id', 'surname', 'credit_score', 'geography',
       'gender', 'age', 'tenure', 'balance', 'num_of_products', 'has_cr_card',
       'is_active_member', 'estimated_salary', 'exited'],
      dtype='object')


# Напишем фунцию для получения информации о данных
def data_frame_info (data_frame):
    display(data_frame.head())
    display('-'* 25)
    list_c = data_frame.columns 
    display('Количество явных дубликатов:', data_frame.duplicated().sum())
    display('-'* 25)

    display(data_frame.info())
    display('-'* 25)

    display(data_frame.hist(figsize=(30, 20)))
    plt.title('Гистограммы для данных в столбцах')
    plt.show()
    display('-'* 25)

    display(data_frame.corr())
    display('-'* 25)

    pd.plotting.scatter_matrix(data_frame, figsize=(30, 20))
    plt.title('Попарные графики распределения')
    plt.show()


    for col_l in list_c:
        display('-'* 25)
        display('Информация для колоки', col_l)
        display(data_frame[col_l].describe())
        display('-'* 25)
        display('Уникальные значения:')
        display(col_l, data_frame[col_l].sort_values().unique())
        display('-'* 25)
        display('Колличество каждого уникального значения:')
        display(data_frame[col_l].value_counts(sort=True, ascending=False))
        display('-'* 25)
        display('Пропуски:')
        display(col_l,': кол-во NaN',data_frame[col_l].isna().sum(),
            ', процент NaN', round(data_frame[col_l].isna().sum()/len(data_frame)*100, 2),'%')


data_frame_info(data)

'-------------------------'

'Количество явных дубликатов:'

0

'-------------------------'

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 10000 entries, 0 to 9999
Data columns (total 14 columns):
 #   Column            Non-Null Count  Dtype  
---  ------            --------------  -----  
 0   row_number        10000 non-null  int64  
 1   customer_id       10000 non-null  int64  
 2   surname           10000 non-null  object 
 3   credit_score      10000 non-null  int64  
 4   geography         10000 non-null  object 
 5   gender            10000 non-null  object 
 6   age               10000 non-null  int64  
 7   tenure            9091 non-null   float64
 8   balance           10000 non-null  float64
 9   num_of_products   10000 non-null  int64  
 10  has_cr_card       10000 non-null  int64  
 11  is_active_member  10000 non-null  int64  
 12  estimated_salary  10000 non-null  float64
 13  exited            10000 non-null  int64  
dtypes: float64(3), int64(8), object(3)
memory usage: 1.1+ MB

None

'-------------------------'

array([[<AxesSubplot:title={'center':'row_number'}>,
        <AxesSubplot:title={'center':'customer_id'}>,
        <AxesSubplot:title={'center':'credit_score'}>],
       [<AxesSubplot:title={'center':'age'}>,
        <AxesSubplot:title={'center':'tenure'}>,
        <AxesSubplot:title={'center':'balance'}>],
       [<AxesSubplot:title={'center':'num_of_products'}>,
        <AxesSubplot:title={'center':'has_cr_card'}>,
        <AxesSubplot:title={'center':'is_active_member'}>],
       [<AxesSubplot:title={'center':'estimated_salary'}>,
        <AxesSubplot:title={'center':'exited'}>, <AxesSubplot:>]],
      dtype=object)

'-------------------------'

'-------------------------'


data[data['tenure'].isna()].sample(5)


data['tenure'].describe()

count    9091.000000
mean        4.997690
std         2.894723
min         0.000000
25%         2.000000
50%         5.000000
75%         7.000000
max        10.000000
Name: tenure, dtype: float64


data['tenure'].value_counts()

1.0     952
2.0     950
8.0     933
3.0     928
5.0     927
7.0     925
4.0     885
9.0     882
6.0     881
10.0    446
0.0     382
Name: tenure, dtype: int64


data['tenure'].isna().sum()

909


data.dropna(inplace=True)
data.info()

<class 'pandas.core.frame.DataFrame'>
Int64Index: 9091 entries, 0 to 9998
Data columns (total 14 columns):
 #   Column            Non-Null Count  Dtype  
---  ------            --------------  -----  
 0   row_number        9091 non-null   int64  
 1   customer_id       9091 non-null   int64  
 2   surname           9091 non-null   object 
 3   credit_score      9091 non-null   int64  
 4   geography         9091 non-null   object 
 5   gender            9091 non-null   object 
 6   age               9091 non-null   int64  
 7   tenure            9091 non-null   float64
 8   balance           9091 non-null   float64
 9   num_of_products   9091 non-null   int64  
 10  has_cr_card       9091 non-null   int64  
 11  is_active_member  9091 non-null   int64  
 12  estimated_salary  9091 non-null   float64
 13  exited            9091 non-null   int64  
dtypes: float64(3), int64(8), object(3)
memory usage: 1.0+ MB


data.drop(columns=['row_number', 'surname', 'customer_id'], inplace=True)
data.info()

<class 'pandas.core.frame.DataFrame'>
Int64Index: 9091 entries, 0 to 9998
Data columns (total 11 columns):
 #   Column            Non-Null Count  Dtype  
---  ------            --------------  -----  
 0   credit_score      9091 non-null   int64  
 1   geography         9091 non-null   object 
 2   gender            9091 non-null   object 
 3   age               9091 non-null   int64  
 4   tenure            9091 non-null   float64
 5   balance           9091 non-null   float64
 6   num_of_products   9091 non-null   int64  
 7   has_cr_card       9091 non-null   int64  
 8   is_active_member  9091 non-null   int64  
 9   estimated_salary  9091 non-null   float64
 10  exited            9091 non-null   int64  
dtypes: float64(3), int64(6), object(2)
memory usage: 852.3+ KB


data_ohe = pd.get_dummies(data, columns=['geography', 'gender'], drop_first=True, dtype='int')

data_ohe.head()


data_ohe.info()

<class 'pandas.core.frame.DataFrame'>
Int64Index: 9091 entries, 0 to 9998
Data columns (total 12 columns):
 #   Column             Non-Null Count  Dtype  
---  ------             --------------  -----  
 0   credit_score       9091 non-null   int64  
 1   age                9091 non-null   int64  
 2   tenure             9091 non-null   float64
 3   balance            9091 non-null   float64
 4   num_of_products    9091 non-null   int64  
 5   has_cr_card        9091 non-null   int64  
 6   is_active_member   9091 non-null   int64  
 7   estimated_salary   9091 non-null   float64
 8   exited             9091 non-null   int64  
 9   geography_Germany  9091 non-null   int32  
 10  geography_Spain    9091 non-null   int32  
 11  gender_Male        9091 non-null   int32  
dtypes: float64(3), int32(3), int64(6)
memory usage: 816.8 KB


target = data_ohe['exited']
features = data_ohe.drop(columns='exited')


rs = 54321


# 3-1-1 = 60 - 40/2 - 40/2 = 60-20-20

features_train, features_valid, target_train, target_valid = train_test_split(
    features, target,  test_size=0.40, stratify=target, random_state=rs
)
features_valid, features_test, target_valid, target_test = train_test_split(
    features_valid, target_valid,  test_size=0.50, stratify=target_valid, random_state=rs
)


data_frame_info(features_train)

'-------------------------'

'Количество явных дубликатов:'

0

'-------------------------'

<class 'pandas.core.frame.DataFrame'>
Int64Index: 5454 entries, 4736 to 1431
Data columns (total 11 columns):
 #   Column             Non-Null Count  Dtype  
---  ------             --------------  -----  
 0   credit_score       5454 non-null   int64  
 1   age                5454 non-null   int64  
 2   tenure             5454 non-null   float64
 3   balance            5454 non-null   float64
 4   num_of_products    5454 non-null   int64  
 5   has_cr_card        5454 non-null   int64  
 6   is_active_member   5454 non-null   int64  
 7   estimated_salary   5454 non-null   float64
 8   geography_Germany  5454 non-null   int32  
 9   geography_Spain    5454 non-null   int32  
 10  gender_Male        5454 non-null   int32  
dtypes: float64(3), int32(3), int64(5)
memory usage: 447.4 KB

None

'-------------------------'

array([[<AxesSubplot:title={'center':'credit_score'}>,
        <AxesSubplot:title={'center':'age'}>,
        <AxesSubplot:title={'center':'tenure'}>],
       [<AxesSubplot:title={'center':'balance'}>,
        <AxesSubplot:title={'center':'num_of_products'}>,
        <AxesSubplot:title={'center':'has_cr_card'}>],
       [<AxesSubplot:title={'center':'is_active_member'}>,
        <AxesSubplot:title={'center':'estimated_salary'}>,
        <AxesSubplot:title={'center':'geography_Germany'}>],
       [<AxesSubplot:title={'center':'geography_Spain'}>,
        <AxesSubplot:title={'center':'gender_Male'}>, <AxesSubplot:>]],
      dtype=object)

'-------------------------'

'-------------------------'


data_frame_info(features_valid)

'-------------------------'

'Количество явных дубликатов:'

0

'-------------------------'

<class 'pandas.core.frame.DataFrame'>
Int64Index: 1818 entries, 2228 to 6205
Data columns (total 11 columns):
 #   Column             Non-Null Count  Dtype  
---  ------             --------------  -----  
 0   credit_score       1818 non-null   int64  
 1   age                1818 non-null   int64  
 2   tenure             1818 non-null   float64
 3   balance            1818 non-null   float64
 4   num_of_products    1818 non-null   int64  
 5   has_cr_card        1818 non-null   int64  
 6   is_active_member   1818 non-null   int64  
 7   estimated_salary   1818 non-null   float64
 8   geography_Germany  1818 non-null   int32  
 9   geography_Spain    1818 non-null   int32  
 10  gender_Male        1818 non-null   int32  
dtypes: float64(3), int32(3), int64(5)
memory usage: 149.1 KB

None

'-------------------------'

array([[<AxesSubplot:title={'center':'credit_score'}>,
        <AxesSubplot:title={'center':'age'}>,
        <AxesSubplot:title={'center':'tenure'}>],
       [<AxesSubplot:title={'center':'balance'}>,
        <AxesSubplot:title={'center':'num_of_products'}>,
        <AxesSubplot:title={'center':'has_cr_card'}>],
       [<AxesSubplot:title={'center':'is_active_member'}>,
        <AxesSubplot:title={'center':'estimated_salary'}>,
        <AxesSubplot:title={'center':'geography_Germany'}>],
       [<AxesSubplot:title={'center':'geography_Spain'}>,
        <AxesSubplot:title={'center':'gender_Male'}>, <AxesSubplot:>]],
      dtype=object)

'-------------------------'

'-------------------------'


data_frame_info(features_test)

'-------------------------'

'Количество явных дубликатов:'

0

'-------------------------'

<class 'pandas.core.frame.DataFrame'>
Int64Index: 1819 entries, 7273 to 9616
Data columns (total 11 columns):
 #   Column             Non-Null Count  Dtype  
---  ------             --------------  -----  
 0   credit_score       1819 non-null   int64  
 1   age                1819 non-null   int64  
 2   tenure             1819 non-null   float64
 3   balance            1819 non-null   float64
 4   num_of_products    1819 non-null   int64  
 5   has_cr_card        1819 non-null   int64  
 6   is_active_member   1819 non-null   int64  
 7   estimated_salary   1819 non-null   float64
 8   geography_Germany  1819 non-null   int32  
 9   geography_Spain    1819 non-null   int32  
 10  gender_Male        1819 non-null   int32  
dtypes: float64(3), int32(3), int64(5)
memory usage: 149.2 KB

None

'-------------------------'

array([[<AxesSubplot:title={'center':'credit_score'}>,
        <AxesSubplot:title={'center':'age'}>,
        <AxesSubplot:title={'center':'tenure'}>],
       [<AxesSubplot:title={'center':'balance'}>,
        <AxesSubplot:title={'center':'num_of_products'}>,
        <AxesSubplot:title={'center':'has_cr_card'}>],
       [<AxesSubplot:title={'center':'is_active_member'}>,
        <AxesSubplot:title={'center':'estimated_salary'}>,
        <AxesSubplot:title={'center':'geography_Germany'}>],
       [<AxesSubplot:title={'center':'geography_Spain'}>,
        <AxesSubplot:title={'center':'gender_Male'}>, <AxesSubplot:>]],
      dtype=object)

'-------------------------'

'-------------------------'


target_train.describe()

count    5454.000000
mean        0.203887
std         0.402923
min         0.000000
25%         0.000000
50%         0.000000
75%         0.000000
max         1.000000
Name: exited, dtype: float64


target_valid.describe()

count    1818.000000
mean        0.204070
std         0.403132
min         0.000000
25%         0.000000
50%         0.000000
75%         0.000000
max         1.000000
Name: exited, dtype: float64


target_test.describe()

count    1819.000000
mean        0.203958
std         0.403049
min         0.000000
25%         0.000000
50%         0.000000
75%         0.000000
max         1.000000
Name: exited, dtype: float64


# все колонки в обучающей выборке
features_test.columns

Index(['credit_score', 'age', 'tenure', 'balance', 'num_of_products',
       'has_cr_card', 'is_active_member', 'estimated_salary',
       'geography_Germany', 'geography_Spain', 'gender_Male'],
      dtype='object')


# запишем признаки, которые ножно маштабировать
numeric_for_scaler = ['credit_score', 'age', 'tenure', 'balance', 'num_of_products', 'estimated_salary']


# создадим и обучим модель, которая сделает для нас стандартизацю, на учебной выборке
scaler = StandardScaler()
scaler.fit(features_train[numeric_for_scaler])
# создадим дубликаты, чтобы в них сохранить результаты стандартизации
features_train_scaler = features_train.copy(deep=True)
features_valid_scaler = features_valid.copy(deep=True)
features_test_scaler = features_test.copy(deep=True)
# стандартизируем все выборки с не целевыми признаками
features_train_scaler[numeric_for_scaler] = scaler.transform(features_train[numeric_for_scaler])
features_valid_scaler[numeric_for_scaler] = scaler.transform(features_valid[numeric_for_scaler])
features_test_scaler[numeric_for_scaler] = scaler.transform(features_test[numeric_for_scaler])


features_train.head()


features_train_scaler.head()


features_valid_scaler.sample()


features_test_scaler.sample()


# функция получает обученную модель, обучающие признаки, целевой признак
# выдате F1-меру
def f_one (model, features_v, target_v):
    predicted_v = model.predict(features_v)
    return f1_score(target_v, predicted_v)


# функция получает обученную модель, обучающие признаки, целевой признак
# выдате меру AUC-ROC
def auc_roc (model, features_v, target_v):
    # найдем вероятность положительного класса
    probabilities_v = model.predict_proba(features_v)
    probabilities_one_v = probabilities_v[:, 1] 
    # посчитаем метрику AUC-ROC
    return roc_auc_score(target_v, probabilities_one_v)


def my_pr_curve (model, features_v, target_v):
    probabilities_valid = model.predict_proba(features_v)
    probabilities_one_valid = probabilities_valid[:, 1]

    precision, recall, thresholds = precision_recall_curve(target_v, probabilities_one_valid)

#    plt.figure()
    plt.figure(figsize=(6, 6))
#    plt.step(precision, recall, where='post')
# recall будет отражаться по оси Y чтобы было аналогично с TPR на ROC кривой.
    plt.plot(precision, recall)

    plt.xlim(0, 1)
    plt.ylim(0, 1)   
    
    plt.xlabel("Precision")
    plt.ylabel("True Positive Rate - Recall")
    
    plt.title('PR- кривая (транспонированная)')
    plt.show


def my_roc_curve (model, features_v, target_v):
    probabilities_valid = model.predict_proba(features_v)
    probabilities_one_valid = probabilities_valid[:, 1]

    fpr, tpr, thresholds = roc_curve(target_v, probabilities_one_valid)

    plt.figure(figsize=(6, 6))
    plt.plot(fpr, tpr)
    
    # ROC-кривая случайной модели (выглядит как прямая)
    plt.plot([0, 1], [0, 1], linestyle='--')
    
    plt.xlim(0, 1)
    plt.ylim(0, 1)

    plt.xlabel("False Positive Rate")
    plt.ylabel("True Positive Rate - Recall")
 
    plt.title("ROC-кривая")
    plt.show()


model = LogisticRegression(random_state=rs
                      #   , solver='liblinear'
                            )
model.fit(features_train, target_train)
# predicted_valid = model.predict(features_valid)
# f1_score(target_valid, predicted_valid)
display ('F1-мера = {:.5f} | AUC-ROC = {:.5f}'.format(f_one(model, features_valid, target_valid), 
                                                     auc_roc(model, features_valid, target_valid)))

'F1-мера = 0.11685 | AUC-ROC = 0.63214'


my_pr_curve(model,features_valid, target_valid)


my_roc_curve(model,features_valid, target_valid)


model = LogisticRegression(random_state=rs
                      #   , solver='liblinear'
                            )
model.fit(features_train_scaler, target_train)
# predicted_valid = model.predict(features_valid)
# f1_score(target_valid, predicted_valid)
display ('F1-мера = {:.5f} | AUC-ROC = {:.5f}'.format(f_one(model, features_valid, target_valid), 
                                                     auc_roc(model, features_valid, target_valid)))

'F1-мера = 0.33897 | AUC-ROC = 0.50104'


my_pr_curve(model,features_valid, target_valid)


my_roc_curve(model,features_valid, target_valid)


# составим списки значений для параметров, которые мы хотим перебрать для поиска наилучшей модели
solver_list = ['lbfgs', 'liblinear', 'newton-cg', 'newton-cholesky', 'sag', 'saga']
c_list = [1, 0.1, 0.2, 0.3 , 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]
penalty_list = ['l2', 'l1', 'elasticnet', None]
l1_ratio_list = [None, 0.1, 0.2, 0.3 , 0.4, 0.5, 0.6, 0.7, 0.8, 0.9] # Только, если penalty = 'elasticnet'

best_result=0
# циклами по этим параметрам дойдем до 
for solver_value in solver_list:
    for c_value in c_list:
        for penalty_value in penalty_list:
            if penalty_value == 'elasticnet':
                for l1_ratio_value in l1_ratio_list:
                    try: # схалявим и вместо изучения всех зависимостей параметров воспользуемся try except
                        model = LogisticRegression( random_state=rs # создания модели без параметры class_weight
                                                   , solver=solver_value
                                                   , C=c_value
                                                   , penalty=penalty_value
                                                   ,l1_ratio=l1_ratio_value
                                                  )
                        model.fit(features_train_scaler, target_train) # обучения модели и проверки ее характеристик
                        predicted_valid = model.predict(features_valid_scaler)
                        result = f1_score(target_valid, predicted_valid) # посчитайте качество модели на валидационной выборке
                    except:
                        result = 0
                    if result > best_result:
                        best_model_logistic_regression = model # сохраните наилучшую модель
                        best_result = result #  сохраните наилучшее значение метрики accuracy на валидационных данных
                        best_solver_value = solver_value
                        best_c_value = c_value
                        best_penalty_value = penalty_value
                        best_l1_ratio_value = l1_ratio_value
            else:
                try:
                    model = LogisticRegression(random_state=rs
                                                   , solver=solver_value
                                                   , C=c_value
                                                   , penalty=penalty_value
                                                   )
                    model.fit(features_train_scaler, target_train)
                    predicted_valid = model.predict(features_valid_scaler)
                    result = f1_score(target_valid, predicted_valid) # посчитайте качество модели на валидационной выборке
                except:
                    result = 0
                if result > best_result:
                        best_model_logistic_regression = model # сохраните наилучшую модель
                        best_result = result #  сохраните наилучшее значение метрики accuracy на валидационных данных
                        best_solver_value = solver_value
                        best_c_value = c_value
                        best_penalty_value = penalty_value
                        
# выведем наши результаты                
display("F1-мера наилучшей модели на проверочной выборке:", best_result)
display('Лучшие параметры:')
display('Solver=', best_solver_value)
display('C=', best_c_value)
display('Penalty=', best_penalty_value)
try:
    display('l1_ratio=', best_l1_ratio_value)
except: 
    display('l1_ratio= None')

'F1-мера наилучшей модели на проверочной выборке:'

0.29514563106796116

'Лучшие параметры:'

'Solver='

'saga'

'C='

1

'Penalty='

'l1'

'l1_ratio= None'


auc_roc(best_model_logistic_regression, features_valid, target_valid)

0.5010366275051832


model = DecisionTreeClassifier(random_state=rs)
model.fit(features_train, target_train)
display ('F1-мера = {:.5f} | AUC-ROC = {:.5f}'.format(f_one(model, features_valid, target_valid), 
                                                     auc_roc(model, features_valid, target_valid)))

'F1-мера = 0.50455 | AUC-ROC = 0.69096'


model = DecisionTreeClassifier(random_state=rs)
model.fit(features_train_scaler, target_train)
display ('F1-мера = {:.5f} | AUC-ROC = {:.5f}'.format(f_one(model, features_valid_scaler, target_valid), 
                                                     auc_roc(model, features_valid_scaler, target_valid)))

'F1-мера = 0.50260 | AUC-ROC = 0.68962'


# создадим датафрейм для записи наших наблюдений
stat_decision_tree = pd.DataFrame(columns=['depth', 'f1', 'auc_roc'])

for depth in range(1, 21):
    model = DecisionTreeClassifier(max_depth=depth, random_state=rs) # задаем параметры модели
    # обучаем модель
    model.fit(features_train_scaler, target_train)
    # записываем данные в датафрейм
    stat_decision_tree = stat_decision_tree.append({'depth': depth
                                                    , 'f1': f_one(model, features_valid_scaler, target_valid)
                                                    , 'auc_roc': auc_roc(model, features_valid_scaler, target_valid)
                                                   }
                                                    , ignore_index=True)
# выводим собранные данные
stat_decision_tree.sort_values(by='f1', ascending=False)


model = RandomForestClassifier(random_state=rs)
model.fit(features_train, target_train)
display ('F1-мера = {:.5f} | AUC-ROC = {:.5f}'.format(f_one(model, features_valid, target_valid), 
                                                     auc_roc(model, features_valid, target_valid)))

'F1-мера = 0.54941 | AUC-ROC = 0.81986'


model = RandomForestClassifier(random_state=rs)
model.fit(features_train_scaler, target_train)
display ('F1-мера = {:.5f} | AUC-ROC = {:.5f}'.format(f_one(model, features_valid_scaler, target_valid), 
                                                     auc_roc(model, features_valid_scaler, target_valid)))

'F1-мера = 0.55184 | AUC-ROC = 0.82016'


%%time 

stat_random_forest = pd.DataFrame(columns=['n_estimators', 'depth', 'f1', 'auc_roc'])

for est in range(1, 21):
    for depth in range(1, 21):
        model = RandomForestClassifier(n_estimators=est, max_depth=depth, random_state=rs) # обучите модель с заданным количеством деревьев
        model.fit(features_train_scaler, target_train) # обучите модель на тренировочной выборке
        # собираем данные
        stat_random_forest = stat_random_forest.append({'depth': depth
                                                        , 'n_estimators': est
                                                        , 'f1': f_one(model, features_valid_scaler, target_valid)
                                                        , 'auc_roc': auc_roc(model, features_valid_scaler, target_valid)
                                                   }
                                                    , ignore_index=True)

stat_random_forest.sort_values(by='f1', ascending=False).head()

Wall time: 34.4 s


def upsample(features, target, repeat):
    features_zeros = features[target == 0]
    features_ones = features[target == 1]
    target_zeros = target[target == 0]
    target_ones = target[target == 1]

    features_upsampled = pd.concat([features_zeros] + [features_ones] * repeat)
    target_upsampled = pd.concat([target_zeros] + [target_ones] * repeat)
    
    features_upsampled, target_upsampled = shuffle(
        features_upsampled, target_upsampled, random_state=rs)
    
    return features_upsampled, target_upsampled


target_train.mean()

0.2038870553722039


upsample_repeat = int(round((1- target_train.mean()) / target_train.mean(), 0))
upsample_repeat

4


features_train_upsampled, target_train_upsampled = upsample(features_train_scaler, target_train, upsample_repeat)


target_train_upsampled.describe()

count    8790.000000
mean        0.506030
std         0.499992
min         0.000000
25%         0.000000
50%         1.000000
75%         1.000000
max         1.000000
Name: exited, dtype: float64


def downsample(features, target, fraction):
    features_zeros = features[target == 0]
    features_ones = features[target == 1]
    target_zeros = target[target == 0]
    target_ones = target[target == 1]

    features_downsampled = pd.concat(
        [features_zeros.sample(frac=fraction)] + [features_ones])
#    target_downsampled = pd.concat(
#        [target_zeros.sample(frac=fraction)] + [target_ones])
    target_downsampled = pd.Series(target, index=features_downsampled.index)

    
    features_downsampled, target_downsampled = shuffle(
        features_downsampled, target_downsampled, random_state=rs)
    
    return features_downsampled, target_downsampled


target_train.mean()

0.2038870553722039


downsample_repeat = 1 / upsample_repeat

features_train_downsampled, target_train_downsampled = downsample(features_train_scaler, target_train, downsample_repeat)


target_train_downsampled.describe()

count    2198.000000
mean        0.505914
std         0.500079
min         0.000000
25%         0.000000
50%         1.000000
75%         1.000000
max         1.000000
Name: exited, dtype: float64


model = LogisticRegression(class_weight='balanced', random_state=rs
#                          , solver='liblinear'
                          )
model.fit(features_train_scaler, target_train)
# predicted_valid = model.predict(features_valid)
# f1_score(target_valid, predicted_valid)

display ('F1-мера = {:.5f} | AUC-ROC = {:.5f}'.format(f_one(model, features_valid_scaler, target_valid), 
                                                     auc_roc(model, features_valid_scaler, target_valid)))

'F1-мера = 0.45336 | AUC-ROC = 0.73296'


model = LogisticRegression(random_state=rs)
model.fit(features_train_upsampled, target_train_upsampled)
display ('F1-мера = {:.5f} | AUC-ROC = {:.5f}'.format(f_one(model, features_valid_scaler, target_valid), 
                                                     auc_roc(model, features_valid_scaler, target_valid)))

'F1-мера = 0.45614 | AUC-ROC = 0.73293'


model = LogisticRegression(random_state=rs)
model.fit(features_train_downsampled, target_train_downsampled)
display ('F1-мера = {:.5f} | AUC-ROC = {:.5f}'.format(f_one(model, features_valid_scaler, target_valid), 
                                                     auc_roc(model, features_valid_scaler, target_valid)))

'F1-мера = 0.45883 | AUC-ROC = 0.73305'


model = LogisticRegression(random_state=rs) # создадим модель
model.fit(features_train_scaler, target_train) # обучим на тренировочной выборке
# найдем вероятность получения положительного класса
probabilities_valid = model.predict_proba(features_valid_scaler)
probabilities_one_valid = probabilities_valid[:, 1]

best_f1 = 0
# best_threshold = 0
# переберем пороги
for threshold in np.arange(0.0, 0.5, 0.02):
    predicted_valid = probabilities_one_valid > threshold # наше предсказание Если больше порога, то положительный класс 1=True
    
    precision = precision_score(target_valid, predicted_valid) # считаем точность
    recall = recall_score(target_valid, predicted_valid) # считаем полноту
    f1 = f1_score(target_valid, predicted_valid) # считаем F1 метрику
    print("Порог = {:.2f} | Точность = {:.3f}, Полнота = {:.3f}, F1 мера = {:.3f}".format(
        threshold, precision, recall, f1))
    
    
    if f1 > best_f1: # выбираем лучшую метрику и фиксируем ее порог
        best_f1 = f1
        best_threshold = threshold
        best_predicted_valid = predicted_valid # проверка результатов
display('Лучший результат')             
display("Порог = {:.2f} | F1 - мера = {:.5f}".format(best_threshold, best_f1))
# best_predicted_valid.mean() # проверка результатов

Порог = 0.00 | Точность = 0.204, Полнота = 1.000, F1 мера = 0.339
Порог = 0.02 | Точность = 0.205, Полнота = 0.997, F1 мера = 0.340
Порог = 0.04 | Точность = 0.217, Полнота = 0.987, F1 мера = 0.355
Порог = 0.06 | Точность = 0.236, Полнота = 0.965, F1 мера = 0.379
Порог = 0.08 | Точность = 0.251, Полнота = 0.919, F1 мера = 0.394
Порог = 0.10 | Точность = 0.268, Полнота = 0.895, F1 мера = 0.412
Порог = 0.12 | Точность = 0.278, Полнота = 0.833, F1 мера = 0.416
Порог = 0.14 | Точность = 0.294, Полнота = 0.790, F1 мера = 0.429
Порог = 0.16 | Точность = 0.311, Полнота = 0.744, F1 мера = 0.438
Порог = 0.18 | Точность = 0.324, Полнота = 0.701, F1 мера = 0.443
Порог = 0.20 | Точность = 0.338, Полнота = 0.666, F1 мера = 0.449
Порог = 0.22 | Точность = 0.362, Полнота = 0.633, F1 мера = 0.461
Порог = 0.24 | Точность = 0.373, Полнота = 0.590, F1 мера = 0.457
Порог = 0.26 | Точность = 0.387, Полнота = 0.547, F1 мера = 0.454
Порог = 0.28 | Точность = 0.413, Полнота = 0.507, F1 мера = 0.455
Порог = 0.30 | Точность = 0.430, Полнота = 0.482, F1 мера = 0.455
Порог = 0.32 | Точность = 0.440, Полнота = 0.447, F1 мера = 0.444
Порог = 0.34 | Точность = 0.451, Полнота = 0.410, F1 мера = 0.429
Порог = 0.36 | Точность = 0.483, Полнота = 0.391, F1 мера = 0.432
Порог = 0.38 | Точность = 0.487, Полнота = 0.356, F1 мера = 0.411
Порог = 0.40 | Точность = 0.489, Полнота = 0.313, F1 мера = 0.382
Порог = 0.42 | Точность = 0.505, Полнота = 0.294, F1 мера = 0.371
Порог = 0.44 | Точность = 0.500, Полнота = 0.267, F1 мера = 0.348
Порог = 0.46 | Точность = 0.522, Полнота = 0.259, F1 мера = 0.346
Порог = 0.48 | Точность = 0.506, Полнота = 0.221, F1 мера = 0.308

'Лучший результат'

'Порог = 0.22 | F1 - мера = 0.46078'


model = LogisticRegression(random_state=rs)
model.fit(features_train_upsampled, target_train_upsampled)
my_pr_curve(model, features_valid_scaler, target_valid)


my_roc_curve(model, features_valid_scaler, target_valid)


# составим списки значений для параметров, которые мы хотим перебрать для поиска наилучшей модели
solver_list = ['lbfgs', 'liblinear', 'newton-cg', 'newton-cholesky', 'sag', 'saga']
c_list = [1, 0.1, 0.2, 0.3 , 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]
penalty_list = ['l2', 'l1', 'elasticnet', None]
l1_ratio_list = [None, 0.1, 0.2, 0.3 , 0.4, 0.5, 0.6, 0.7, 0.8, 0.9] # Только, если penalty = 'elasticnet'

best_result=0
# циклами по этим параметрам дойдем до 
for solver_value in solver_list:
    for c_value in c_list:
        for penalty_value in penalty_list:
            if penalty_value == 'elasticnet':
                for l1_ratio_value in l1_ratio_list:
                    try: # схалявим и вместо изучения всех зависимостей параметров воспользуемся try except
                        model = LogisticRegression( random_state=rs
                                                   , class_weight='balanced'# создание модели
                                                   , solver=solver_value
                                                   , C=c_value
                                                   , penalty=penalty_value
                                                   ,l1_ratio=l1_ratio_value
                                                  )
                        model.fit(features_train_scaler, target_train) # обучения модели и проверки ее характеристик
                        predicted_valid = model.predict(features_valid_scaler)
                        result = f1_score(target_valid, predicted_valid) # посчитайте качество модели на валидационной выборке
                    except:
                        result = 0
                    if result > best_result:
                        best_model_logistic_regression = model # сохраните наилучшую модель
                        best_result = result #  сохраните наилучшее значение метрики accuracy на валидационных данных
                        best_solver_value = solver_value
                        best_c_value = c_value
                        best_penalty_value = penalty_value
                        best_l1_ratio_value = l1_ratio_value
            else:
                try:
                    model = LogisticRegression( random_state=rs
                                               , class_weight='balanced'
                                               , solver=solver_value
                                               , C=c_value
                                               , penalty=penalty_value
                                               )
                    model.fit(features_train_scaler, target_train)
                    predicted_valid = model.predict(features_valid_scaler)
                    result = f1_score(target_valid, predicted_valid) # посчитайте качество модели на валидационной выборке
                except:
                    result = 0
                if result > best_result:
                        best_model_logistic_regression = model # сохраните наилучшую модель
                        best_result = result #  сохраните наилучшее значение метрики accuracy на валидационных данных
                        best_solver_value = solver_value
                        best_c_value = c_value
                        best_penalty_value = penalty_value
                        
# выведем наши результаты                
display("F1-мера наилучшей модели на проверочной выборке:", best_result)
display('Лучшие параметры:')
display('Solver=', best_solver_value)
display('C=', best_c_value)
display('Penalty=', best_penalty_value)
try:
    display('l1_ratio=', best_l1_ratio_value)
except: 
    display('l1_ratio= None')

'F1-мера наилучшей модели на проверочной выборке:'

0.45966228893058164

'Лучшие параметры:'

'Solver='

'liblinear'

'C='

0.1

'Penalty='

'l1'

'l1_ratio= None'


auc_roc(best_model_logistic_regression, features_valid_scaler, target_valid)

0.734342081488422


model = DecisionTreeClassifier(random_state=rs
                               , class_weight='balanced'
)
model.fit(features_train_scaler, target_train)
display ('F1-мера = {:.5f} | AUC-ROC = {:.5f}'.format(f_one(model, features_valid_scaler, target_valid), 
                                                     auc_roc(model, features_valid_scaler, target_valid)))

'F1-мера = 0.46175 | AUC-ROC = 0.66142'


model = DecisionTreeClassifier(random_state=rs)
model.fit(features_train_upsampled, target_train_upsampled)
display ('F1-мера = {:.5f} | AUC-ROC = {:.5f}'.format(f_one(model, features_valid_scaler, target_valid), 
                                                     auc_roc(model, features_valid_scaler, target_valid)))

'F1-мера = 0.47581 | AUC-ROC = 0.67082'


model = DecisionTreeClassifier(random_state=rs)
model.fit(features_train_downsampled, target_train_downsampled)
display ('F1-мера = {:.5f} | AUC-ROC = {:.5f}'.format(f_one(model, features_valid_scaler, target_valid), 
                                                     auc_roc(model, features_valid_scaler, target_valid)))

'F1-мера = 0.47249 | AUC-ROC = 0.68561'


# создадим датафрейм для записи наших наблюдений
stat_decision_tree = pd.DataFrame(columns=['depth', 'f1', 'auc_roc'])

for depth in range(1, 11):
    model = DecisionTreeClassifier( random_state=rs
                                   , max_depth=depth
#        , class_weight='balanced'
    ) # задаем параметры модели
    # обучаем модель
    model.fit(features_train_upsampled, target_train_upsampled)
    # model.fit(features_train_downsampled, target_train_downsampled)
    # model.fit(features_train, target_train)
    # записываем данные в датафрейм
    stat_decision_tree = stat_decision_tree.append({'depth': depth
                                                    , 'f1': f_one(model, features_valid_scaler, target_valid)
                                                    , 'auc_roc': auc_roc(model, features_valid_scaler, target_valid)
                                                   }
                                                    , ignore_index=True)
# выводим собранные данные
stat_decision_tree.sort_values(by='f1', ascending=False)


# создадим датафрейм для записи наших наблюдений
stat_decision_tree = pd.DataFrame(columns=['depth', 'f1', 'auc_roc'])

for depth in range(1, 11):
    model = DecisionTreeClassifier( random_state=rs
                                   , max_depth=depth
                                   , class_weight='balanced'
                                   ) # задаем параметры модели
    # обучаем модель
    # model.fit(features_train_upsampled, target_train_upsampled)
    # model.fit(features_train_downsampled, target_train_downsampled)
    model.fit(features_train_scaler, target_train)
    # записываем данные в датафрейм
    stat_decision_tree = stat_decision_tree.append({'depth': depth
                                                    , 'f1': f_one(model, features_valid_scaler, target_valid)
                                                    , 'auc_roc': auc_roc(model, features_valid_scaler, target_valid)
                                                   }
                                                    , ignore_index=True)
# выводим собранные данные
stat_decision_tree.sort_values(by='f1', ascending=False)


# создадим датафрейм для записи наших наблюдений
stat_decision_tree = pd.DataFrame(columns=['depth', 'f1', 'auc_roc'])

for depth in range(1, 11):
    model = DecisionTreeClassifier(random_state=rs
                                   , max_depth=depth
#                                   , class_weight='balanced'
                                    ) # задаем параметры модели
    # обучаем модель
    # model.fit(features_train_upsampled, target_train_upsampled)
    model.fit(features_train_downsampled, target_train_downsampled)
    # model.fit(features_train, target_train)
    # записываем данные в датафрейм
    stat_decision_tree = stat_decision_tree.append({'depth': depth
                                                    , 'f1': f_one(model, features_valid_scaler, target_valid)
                                                    , 'auc_roc': auc_roc(model, features_valid_scaler, target_valid)
                                                   }
                                                    , ignore_index=True)
# выводим собранные данные
stat_decision_tree.sort_values(by='f1', ascending=False)


model = RandomForestClassifier(random_state=rs, class_weight='balanced')
model.fit(features_train_scaler, target_train)
display ('F1-мера = {:.5f} | AUC-ROC = {:.5f}'.format(f_one(model, features_valid_scaler, target_valid), 
                                                     auc_roc(model, features_valid_scaler, target_valid)))

'F1-мера = 0.53565 | AUC-ROC = 0.82198'


model = RandomForestClassifier(random_state=rs)
# model.fit(features_train_downsampled, target_train_downsampled)
model.fit(features_train_downsampled, target_train_downsampled)
display ('F1-мера = {:.5f} | AUC-ROC = {:.5f}'.format(f_one(model, features_valid_scaler, target_valid), 
                                                     auc_roc(model, features_valid_scaler, target_valid)))

'F1-мера = 0.55385 | AUC-ROC = 0.81775'


model = RandomForestClassifier(random_state=rs)
# model.fit(features_train_downsampled, target_train_downsampled)
model.fit(features_train_upsampled, target_train_upsampled)
display ('F1-мера = {:.5f} | AUC-ROC = {:.5f}'.format(f_one(model, features_valid_scaler, target_valid), 
                                                     auc_roc(model, features_valid_scaler, target_valid)))

'F1-мера = 0.57399 | AUC-ROC = 0.81779'


%%time 

stat_random_forest = pd.DataFrame(columns=['n_estimators', 'depth', 'f1', 'auc_roc'])

for est in range(1, 21):
    for depth in range(1, 21):
        model = RandomForestClassifier(n_estimators=est, max_depth=depth, class_weight='balanced', random_state=rs) # обучите модель с заданным количеством деревьев
        model.fit(features_train_scaler, target_train) # обучите модель на тренировочной выборке
        # собираем данные
        stat_random_forest = stat_random_forest.append({'depth': depth
                                                        , 'n_estimators': est
                                                        , 'f1': f_one(model, features_valid_scaler, target_valid)
                                                        , 'auc_roc': auc_roc(model, features_valid_scaler, target_valid)
                                                   }
                                                    , ignore_index=True)

stat_random_forest.sort_values(by='f1', ascending=False).head(10)

Wall time: 35.2 s


%%time 

stat_random_forest = pd.DataFrame(columns=['n_estimators', 'depth', 'f1', 'auc_roc'])

for est in range(1, 41):
    for depth in range(1, 21):
        model = RandomForestClassifier(n_estimators=est, max_depth=depth, random_state=rs) # обучите модель с заданным количеством деревьев
        model.fit(features_train_downsampled, target_train_downsampled) # обучите модель на тренировочной выборке
        # собираем данные
        stat_random_forest = stat_random_forest.append({'depth': depth
                                                        , 'n_estimators': est
                                                        , 'f1': f_one(model, features_valid_scaler, target_valid)
                                                        , 'auc_roc': auc_roc(model, features_valid_scaler, target_valid)
                                                   }
                                                    , ignore_index=True)

stat_random_forest.sort_values(by='f1', ascending=False).head(10)

Wall time: 1min 24s


%%time 

stat_random_forest = pd.DataFrame(columns=['n_estimators', 'depth', 'f1', 'auc_roc'])

for est in range(1, 31):
    for depth in range(1, 31):
        model = RandomForestClassifier(n_estimators=est, max_depth=depth, random_state=rs) # обучите модель с заданным количеством деревьев
        model.fit(features_train_upsampled, target_train_upsampled) # обучите модель на тренировочной выборке
        # собираем данные
        stat_random_forest = stat_random_forest.append({'depth': depth
                                                        , 'n_estimators': est
                                                        , 'f1': f_one(model, features_valid_scaler, target_valid)
                                                        , 'auc_roc': auc_roc(model, features_valid_scaler, target_valid)
                                                   }
                                                    , ignore_index=True)

stat_random_forest.sort_values(by='f1', ascending=False).head(10)

Wall time: 2min 33s


# создадим модель чемпиона
best_random_forest_model = RandomForestClassifier(random_state=rs
                                                  , n_estimators=19
                                                  , max_depth=26
#                                                  , class_weight='balanced'
                                                 )
#обучим чемпиона на маштабированных признаках при сбалансированном целевом признаке
best_random_forest_model.fit(features_train_upsampled, target_train_upsampled)
# best_random_forest_model.fit(features_train_downsampled, target_train_downsampled)
# best_random_forest_model.fit(features_train_scaler, target_train)

RandomForestClassifier(max_depth=26, n_estimators=19, random_state=54321)


display ('F1-мера = {:.5f} | AUC-ROC = {:.5f}'.format(f_one(best_random_forest_model, features_test_scaler, target_test), 
                                                     auc_roc(best_random_forest_model, features_test_scaler, target_test)))

'F1-мера = 0.59944 | AUC-ROC = 0.83485'

	RowNumber	CustomerId	Surname	CreditScore	Geography	Gender	Age	Tenure	Balance	NumOfProducts	HasCrCard	IsActiveMember	EstimatedSalary	Exited
0	1	15634602	Hargrave	619	France	Female	42	2.0	0.00	1	1	1	101348.88	1
1	2	15647311	Hill	608	Spain	Female	41	1.0	83807.86	1	0	1	112542.58	0
2	3	15619304	Onio	502	France	Female	42	8.0	159660.80	3	1	0	113931.57	1
3	4	15701354	Boni	699	France	Female	39	1.0	0.00	2	0	0	93826.63	0
4	5	15737888	Mitchell	850	Spain	Female	43	2.0	125510.82	1	1	1	79084.10	0

	row_number	customer_id	surname	credit_score	geography	gender	age	tenure	balance	num_of_products	has_cr_card	is_active_member	estimated_salary	exited
0	1	15634602	Hargrave	619	France	Female	42	2.0	0.00	1	1	1	101348.88	1
1	2	15647311	Hill	608	Spain	Female	41	1.0	83807.86	1	0	1	112542.58	0
2	3	15619304	Onio	502	France	Female	42	8.0	159660.80	3	1	0	113931.57	1
3	4	15701354	Boni	699	France	Female	39	1.0	0.00	2	0	0	93826.63	0
4	5	15737888	Mitchell	850	Spain	Female	43	2.0	125510.82	1	1	1	79084.10	0

	row_number	customer_id	credit_score	age	tenure	balance	num_of_products	has_cr_card	is_active_member	estimated_salary	exited
row_number	1.000000	0.004202	0.005840	0.000783	-0.007322	-0.009067	0.007246	0.000599	0.012044	-0.005988	-0.016571
customer_id	0.004202	1.000000	0.005308	0.009497	-0.021418	-0.012419	0.016972	-0.014025	0.001665	0.015271	-0.006248
credit_score	0.005840	0.005308	1.000000	-0.003965	-0.000062	0.006268	0.012238	-0.005458	0.025651	-0.001384	-0.027094
age	0.000783	0.009497	-0.003965	1.000000	-0.013134	0.028308	-0.030680	-0.011721	0.085472	-0.007201	0.285323
tenure	-0.007322	-0.021418	-0.000062	-0.013134	1.000000	-0.007911	0.011979	0.027232	-0.032178	0.010520	-0.016761
balance	-0.009067	-0.012419	0.006268	0.028308	-0.007911	1.000000	-0.304180	-0.014858	-0.010084	0.012797	0.118533
num_of_products	0.007246	0.016972	0.012238	-0.030680	0.011979	-0.304180	1.000000	0.003183	0.009612	0.014204	-0.047820
has_cr_card	0.000599	-0.014025	-0.005458	-0.011721	0.027232	-0.014858	0.003183	1.000000	-0.011866	-0.009933	-0.007138
is_active_member	0.012044	0.001665	0.025651	0.085472	-0.032178	-0.010084	0.009612	-0.011866	1.000000	-0.011421	-0.156128
estimated_salary	-0.005988	0.015271	-0.001384	-0.007201	0.010520	0.012797	0.014204	-0.009933	-0.011421	1.000000	0.012097
exited	-0.016571	-0.006248	-0.027094	0.285323	-0.016761	0.118533	-0.047820	-0.007138	-0.156128	0.012097	1.000000

	credit_score	age	tenure	balance	num_of_products	has_cr_card	is_active_member	estimated_salary	geography_Germany	geography_Spain	gender_Male
credit_score	1.000000	-0.003679	-0.007329	0.004633	0.003031	0.003015	0.027371	-0.008305	-0.007066	0.004265	-0.017097
age	-0.003679	1.000000	-0.011031	0.030107	-0.026815	-0.018054	0.071512	-0.002584	0.058367	-0.008131	-0.016069
tenure	-0.007329	-0.011031	1.000000	-0.007759	0.015903	0.032542	-0.028362	0.002300	-0.010290	-0.000654	0.017140
balance	0.004633	0.030107	-0.007759	1.000000	-0.298937	-0.021780	-0.007702	0.022207	0.406291	-0.142702	0.002475
num_of_products	0.003031	-0.026815	0.015903	-0.298937	1.000000	0.006731	0.011066	0.014886	-0.005970	0.017134	-0.015875
has_cr_card	0.003015	-0.018054	0.032542	-0.021780	0.006731	1.000000	0.000438	-0.012973	0.006663	0.000631	0.015197
is_active_member	0.027371	0.071512	-0.028362	-0.007702	0.011066	0.000438	1.000000	-0.019026	-0.012022	0.007164	0.018872
estimated_salary	-0.008305	-0.002584	0.002300	0.022207	0.014886	-0.012973	-0.019026	1.000000	0.032323	-0.012693	-0.005145
geography_Germany	-0.007066	0.058367	-0.010290	0.406291	-0.005970	0.006663	-0.012022	0.032323	1.000000	-0.332857	-0.030655
geography_Spain	0.004265	-0.008131	-0.000654	-0.142702	0.017134	0.000631	0.007164	-0.012693	-0.332857	1.000000	0.008605
gender_Male	-0.017097	-0.016069	0.017140	0.002475	-0.015875	0.015197	0.018872	-0.005145	-0.030655	0.008605	1.000000

	credit_score	age	tenure	balance	num_of_products	has_cr_card	is_active_member	estimated_salary	geography_Germany	geography_Spain	gender_Male
credit_score	1.000000	-0.017967	0.011371	-0.007716	0.027334	-0.032377	0.063564	0.066390	0.028791	-0.002512	0.018312
age	-0.017967	1.000000	0.016463	0.031123	-0.022191	-0.004509	0.105194	-0.036407	0.031527	-0.001333	-0.016432
tenure	0.011371	0.016463	1.000000	-0.023194	0.012758	0.026370	-0.011046	0.018162	0.018920	-0.007902	0.014368
balance	-0.007716	0.031123	-0.023194	1.000000	-0.299169	-0.001760	0.002331	0.014727	0.394823	-0.103341	0.044682
num_of_products	0.027334	-0.022191	0.012758	-0.299169	1.000000	0.003707	0.014329	0.006751	-0.026415	-0.007575	-0.037365
has_cr_card	-0.032377	-0.004509	0.026370	-0.001760	0.003707	1.000000	-0.015673	0.022679	0.010731	-0.043535	-0.011424
is_active_member	0.063564	0.105194	-0.011046	0.002331	0.014329	-0.015673	1.000000	-0.023141	-0.016895	0.023575	0.039770
estimated_salary	0.066390	-0.036407	0.018162	0.014727	0.006751	0.022679	-0.023141	1.000000	-0.037778	0.008860	0.000059
geography_Germany	0.028791	0.031527	0.018920	0.394823	-0.026415	0.010731	-0.016895	-0.037778	1.000000	-0.324457	-0.002218
geography_Spain	-0.002512	-0.001333	-0.007902	-0.103341	-0.007575	-0.043535	0.023575	0.008860	-0.324457	1.000000	0.022893
gender_Male	0.018312	-0.016432	0.014368	0.044682	-0.037365	-0.011424	0.039770	0.000059	-0.002218	0.022893	1.000000

	row_number	customer_id	surname	credit_score	geography	gender	age	tenure	balance	num_of_products	has_cr_card	is_active_member	estimated_salary	exited
3100	3101	15735549	Lori	810	Germany	Male	35	NaN	96814.46	2	1	1	120511.03	0
2630	2631	15600879	Parsons	554	Germany	Female	36	NaN	157780.93	2	1	0	6089.13	0
1202	1203	15724334	Alekseyeva	529	France	Male	22	NaN	0.00	1	1	0	151169.83	0
7053	7054	15815271	Ritchie	755	Germany	Male	43	NaN	165048.50	3	1	0	16929.41	1
353	354	15812007	Power	670	Spain	Male	25	NaN	0.00	2	1	1	78358.94	0

	credit_score	age	tenure	balance	num_of_products	has_cr_card	is_active_member	estimated_salary	gender_Male
4736	638	32	0.0	0.00	2	1	0	160129.99	0
873	561	28	7.0	0.00	2	1	0	7797.01	1
2093	555	55	4.0	146798.81	1	1	1	74149.77	1
6859	733	38	3.0	157658.36	1	0	0	19658.43	0
7624	728	69	1.0	0.00	2	1	1	131804.86	0

	credit_score	age	tenure	balance	num_of_products	has_cr_card	is_active_member	estimated_salary	geography_Spain	gender_Male
2228	644	37	8.0	0.00	2	1	0	20968.88	0	0
7188	708	34	4.0	0.00	1	1	1	62868.33	0	0
168	667	39	2.0	0.00	2	1	0	40721.24	1	0
9133	705	36	1.0	111629.29	1	1	1	21807.16	1	1
9204	646	30	5.0	0.00	2	1	0	13935.32	0	0

	credit_score	age	tenure	balance	num_of_products	has_cr_card	is_active_member	estimated_salary	geography_Germany	geography_Spain	gender_Male
7273	660	38	6.0	109869.32	1	1	1	154641.91	0	1	1
2604	540	25	5.0	116160.23	1	1	0	13411.67	0	0	1
9542	644	37	9.0	0.00	2	1	1	96442.86	0	1	1
6721	824	77	3.0	27517.15	2	0	1	2746.41	1	0	1
744	650	60	8.0	0.00	2	1	1	102925.76	0	0	1

	credit_score	age	tenure	balance	num_of_products	has_cr_card	is_active_member	estimated_salary	geography_Germany	geography_Spain	gender_Male
credit_score	1.000000	0.007739	0.009746	0.007268	0.019604	0.003812	0.007206	-0.015335	-0.006182	-0.001028	-0.009357
age	0.007739	1.000000	-0.049370	0.037211	-0.057679	-0.011727	0.091825	0.007477	0.041367	-0.004299	-0.063278
tenure	0.009746	-0.049370	1.000000	0.007149	-0.000843	0.012067	-0.066016	0.026438	-0.003929	0.013085	-0.002294
balance	0.007268	0.037211	0.007149	1.000000	-0.312872	-0.029152	0.003106	-0.008472	0.393998	-0.153041	0.038980
num_of_products	0.019604	-0.057679	-0.000843	-0.312872	1.000000	0.005746	-0.001204	0.017667	-0.002494	0.014994	-0.042042
has_cr_card	0.003812	-0.011727	0.012067	-0.029152	0.005746	1.000000	-0.032803	-0.014457	0.014248	-0.046253	-0.002763
is_active_member	0.007206	0.091825	-0.066016	0.003106	-0.001204	-0.032803	1.000000	-0.020709	-0.032877	0.027448	0.031759
estimated_salary	-0.015335	0.007477	0.026438	-0.008472	0.017667	-0.014457	-0.020709	1.000000	-0.001896	-0.026500	0.001772
geography_Germany	-0.006182	0.041367	-0.003929	0.393998	-0.002494	0.014248	-0.032877	-0.001896	1.000000	-0.340911	-0.022622
geography_Spain	-0.001028	-0.004299	0.013085	-0.153041	0.014994	-0.046253	0.027448	-0.026500	-0.340911	1.000000	0.027817
gender_Male	-0.009357	-0.063278	-0.002294	0.038980	-0.042042	-0.002763	0.031759	0.001772	-0.022622	0.027817	1.000000

	credit_score	age	tenure	balance	num_of_products	has_cr_card	is_active_member	estimated_salary	gender_Male
4736	-0.138957	-0.651932	-1.730483	-1.236007	0.813165	1	0	1.054342	0
873	-0.942705	-1.037670	0.702005	-1.236007	0.813165	1	0	-1.594705	1
2093	-1.005334	1.566062	-0.340490	1.119232	-0.899191	1	1	-0.440841	1
6859	0.852680	-0.073325	-0.687988	1.293462	-0.899191	0	0	-1.388437	0
7624	0.800488	2.916145	-1.382985	-1.236007	0.813165	1	1	0.561772	0

	depth	f1	auc_roc
7	8.0	0.539535	0.805573
6	7.0	0.526316	0.815569
9	10.0	0.522936	0.757026
10	11.0	0.521610	0.738979
8	9.0	0.517915	0.770197
12	13.0	0.515320	0.714891
11	12.0	0.514970	0.719922
5	6.0	0.508651	0.808473
14	15.0	0.504828	0.708567
15	16.0	0.503259	0.710410
18	19.0	0.502604	0.696843
16	17.0	0.501326	0.705471
17	18.0	0.501305	0.703881
3	4.0	0.487136	0.787273
19	20.0	0.487047	0.682367
13	14.0	0.486639	0.703647
1	2.0	0.483307	0.700889
4	5.0	0.471483	0.807744
2	3.0	0.442344	0.759486
0	1.0	0.000000	0.643314

	n_estimators	depth	f1	auc_roc
174	9.0	15.0	0.559350	0.795313
130	7.0	11.0	0.558824	0.808168
169	9.0	10.0	0.556492	0.812855
230	12.0	11.0	0.555740	0.811396
250	13.0	11.0	0.554817	0.812032

	depth	f1	auc_roc
4	5.0	0.535637	0.794135
6	7.0	0.527331	0.784590
5	6.0	0.523017	0.788113
7	8.0	0.512432	0.771396
8	9.0	0.500000	0.755652
3	4.0	0.490672	0.771262
9	10.0	0.488121	0.726802
2	3.0	0.485839	0.762811
1	2.0	0.473054	0.715362
0	1.0	0.442623	0.656689

	depth	f1	auc_roc
4	5.0	0.535637	0.794135
6	7.0	0.524168	0.779524
5	6.0	0.523017	0.788113
7	8.0	0.513543	0.771785
8	9.0	0.497863	0.753218
3	4.0	0.490672	0.771262
9	10.0	0.487541	0.726636
2	3.0	0.485839	0.762811
1	2.0	0.473054	0.715362
0	1.0	0.442623	0.656689

	depth	f1	auc_roc
6	7.0	0.544102	0.790225
5	6.0	0.539166	0.804736
4	5.0	0.534054	0.803388
3	4.0	0.528662	0.784473
7	8.0	0.528616	0.766363
8	9.0	0.512974	0.755984
9	10.0	0.495540	0.734423
1	2.0	0.483493	0.716623
2	3.0	0.483493	0.769027
0	1.0	0.447859	0.658830

	n_estimators	depth	f1	auc_roc
267	14.0	8.0	0.563482	0.815784
206	11.0	7.0	0.560748	0.815211
287	15.0	8.0	0.560292	0.815104
307	16.0	8.0	0.558931	0.815035
347	18.0	8.0	0.558140	0.812727
327	17.0	8.0	0.557856	0.814618
252	13.0	13.0	0.555891	0.816991
248	13.0	9.0	0.555698	0.813145
226	12.0	7.0	0.554642	0.814732
151	8.0	12.0	0.554286	0.796849

	n_estimators	depth	f1	auc_roc
358	18.0	19.0	0.559917	0.806902
748	38.0	9.0	0.558824	0.816808
728	37.0	9.0	0.558577	0.816503
788	40.0	9.0	0.558577	0.816952
768	39.0	9.0	0.557308	0.816715
729	37.0	10.0	0.557173	0.815482
169	9.0	10.0	0.554639	0.805756
609	31.0	10.0	0.554622	0.813620
573	29.0	14.0	0.554315	0.809793
709	36.0	10.0	0.554292	0.815762

	n_estimators	depth	f1	auc_roc
569	19.0	30.0	0.598025	0.807880
568	19.0	29.0	0.598025	0.807880
567	19.0	28.0	0.598025	0.807880
566	19.0	27.0	0.598025	0.807880
565	19.0	26.0	0.598025	0.807880
564	19.0	25.0	0.592384	0.807215
503	17.0	24.0	0.590071	0.807007
563	19.0	24.0	0.590071	0.807904
504	17.0	25.0	0.588402	0.805990
440	15.0	21.0	0.587079	0.808900

Отток клиентов из "Бета-Банка"

Отток клиентов из "Бета-Банка"¶

Введение¶

Библиотеки и настройки¶

Библиотеки¶

Настройки¶

Подготовка данных¶

Загрузка данных из файла¶

Переимнование колонок¶

Познакомимся с данными¶

Попытка спасти данные¶

Удаление пропусков и не нужных столбцов¶

Получение дамми-признаков¶

Исследование задачи¶

Классы и подклассы задач¶

Целевой признак и обучающие данные¶

Генератор псевдослучайных значений¶

Разбиение данных на выборки¶

Маштабирование признаков¶

Метрики¶

Модели¶

Логистическая регрессия¶

Настройки по умолчанию¶

Улучшение модели¶

Дерево Решений¶

Настройки по умолчанию¶

Улучшение модели¶

Случайный лес¶

Настройки по умолчанию¶

Улучшение модели¶

Борьба с дисбалансом¶

Обучающая выборка upsampling¶

Обучающая выборка downsampling¶

Логистическая регрессия¶

Настройки по умолчанию¶

Взвешивание классов.¶

Upsampling¶

Downsampling¶

Изменение порога точности¶

Улучшение модели¶

Дерево Решений¶

Настройки по умолчанию¶

Взвешивание классов¶

Upsamling¶

Downsampling¶

Улучшение модели¶

Upnsampling¶

Взвешивание классов¶

Downsampling¶

Случайный лес¶

Настройки по умолчанию¶

Взвешивание классов¶

Downsampling¶

Upsampling¶

Улучшение модели¶

Взвешивание классов¶

Downsampling¶

Upsampling¶

Тестирование модели¶

Общий вывод¶